﻿#define _CRT_SECURE_NO_WARNINGS 1

#include<iostream>
#include<vector>
#include<string>
#include <algorithm>
using namespace std;


//class Date
//{
//public:
//	void Init(int year, int month, int day)
//	{
//		_year = year;
//		_month = month;
//		_day = day;
//	}
//
//	void Print()
//	{
//		cout << _year << "/" << _month << "/" << _day << endl;
//	}
//
//
//private:
//	// 这里只是声明，没有开空间
//	int _year;
//	int _month;
//	int _day;
//};

class A
{
public:
	void Print()
	{
		cout << this << endl;
		cout << "A:Printf()" << endl;
	}

private:
	int _a;
};

//int main()
//{
//	/*Date d1;
//	Date d2;
//
//	d1.Init(2024, 5, 1);
//	d1.Print();
//
//	d2.Init(2024, 6, 26);
//	d2.Print();*/
//
//	A* p = nullptr;
//	//正常运行
//	//p作为对象地址传递过去被this指针接收，用于区分对象
//	
//	           //mov ecx p
//	         
//	p->Print();//call 地址
//
//	return 0;
//}


///////////////////////////////////////////////
//构造函数 用途不是构造 是初始化

//class Date
//{
//public:
//	//1.无参数构造函数
//	/*Date()
//	{
//		_year = 1;
//		_month = 1;
//		_day = 1;
//	}*/
//
//	//2.带参数构造函数
//	/*Date(int year, int month, int day)
//	{
//		_year = year;
//		_month = month;
//		_day = day;
//	}*/
//	
//	//3.全缺省构造函数 可以代替上面两种
//	Date(int year = 2024, int month = 7, int day =10)
//	{
//		_year = year;
//		_month = month;
//		_day = day;
//	}
//
//
//
//	void Print()
//	{
//		cout << _year << "/" << _month << "/" << _day << endl;
//	}
//
//
//private:
//	// 这里只是声明，没有开空间
//	int _year;
//	int _month;
//	int _day;
//};
//
//int main()
//{
//	Date d1; //无参调用默认的构造函数 用缺省值，不能加括号， 编译器无法区分是函数
//	//还是实例化对象
//	d1.Print(); 
//
//	Date d2(2024, 6, 24);//调用传值构造函数
//	d2.Print();
//
//	Date d3; //无参构造，调用不加括号， 编译器无法区分是函数
//	//还是实例化对象
//	d3.Print();
//	return 0;
//}
//typedef int STDataType;
//
//class Stack
//{
//public:
//	Stack(int n = 4)
//	{
//		_a = (STDataType*)malloc(sizeof(STDataType) * n);
//		if (_a == nullptr)
//		{
//			perror("malloc fail!");
//			return;
//		}
//		_capacity = n;
//		_top = 0;
//	}
//
//	~Stack()
//	{
//		cout << "~Stack()" << endl;
//		free(_a);
//		_a = nullptr;
//		_top = _capacity = 0;
//	}
//
//private:
//	STDataType* _a;
//	int _capacity;
//	int _top;
//};

//class MyQueue
//{
//public:
//	//自定义类型 stack， /编译器默认（⽣成）MyQueue的构造函数调⽤了Stack的构造，
//	// 完成了两个成员的初始化
//
//private:
//	Stack pushst;
//	Stack popst;
//};

//int main()
//{
//	MyQueue mq;
//	return 0;
//}

//class Date
//{
//public:
//	Date(int year = 1, int month = 1, int day = 1)
//	{
//		_year = year;
//		_month = month;
//		_day = day;
//	}
//
//	bool operator==(Date d2)
//	{
//		return _year == d2._year
//			&& _month == d2._month
//			&& _day == d2._day;
//	}
//
//	void Print()
//	{
//		cout << _year << "/" << _month << "/" << _day << endl;
//	}
//private:
//	int _year;
//	int _month;
//	int _day;
//};

//int main()
//{
//	Date x1(2024, 7, 10);
//	Date x2(2024, 7, 10);
//
//	x1.operator==(x2);
//	if (x1 == x2)
//	{
//		printf("true\n");
//	}
//
//	return 0;
//}
//#include<stdlib.h>
//
//namespace Moss
//{
//	int rand = 15;
//}
//
//int main()
//{
//
//	printf("%d\n", Moss::rand);
//	return 0;
//}

//void Func1(int a = 1, int b = 2, int c = 3)
//{
//	cout << "a = " << a << endl;
//	cout << "b = " << b << endl;
//	cout << "c = " << c << endl;
//}
//
//void Func2(int d, int e = 5, int f = 6)
//{
//	cout << "d = " << d << endl;
//	cout << "e = " << e << endl;
//	cout << "f = " << f << endl;
//}

//int main()
//{
//	Func1();//全缺省
//	Func2(4);//半缺省
//	return 0;
//}

//int Add(int x, int y)
//{
//	return (x + y);
//}
//
//double Add(double x, double y)
//{
//	return (x + y);
//}
//
//void F(int a)
//{
//	cout << "F(int a)" << endl;
//}
//
//void F()
//{
//	cout << "F()" << endl;
//}
//
//void Func(char* s, int n)
//{
//	return;
//}
//
//void Func(int n, char* s)
//{
//	return;
//}

//void F(int a = 1, int b = 2)
//{
//	cout << "F(int a = 1, int b = 2)" << endl;
//}
//
//void F()
//{
//	cout << "F()" << endl;
//}
// 
//void Swap(int& x, int& y)//引用传参 可以替换 传址调用
//{
//	int tmp = x;
//	x = y;
//	y = tmp;
//}
//
//int main()
//{
//	//int a = 10;
//
//	////给a取别名b、c
//	//int& b = a;
//	//int& c = a;
//
//	////可以取别名的别名
//	//int& d = c;
//
//
//	//int a = 5;
//
//	////编译错： ra必须初始化引用
//	////int& ra;
//
//	//int& b = a;
//
//	//int c = 10;
//	////这里是赋值，将c的值赋给b（a），不是改变引用的指向
//	//b = c;
//
//	//const int a = 10;
//	////权限不能放大，必须用const引用
//	////int& ra = a;
//	//const int& ra = a;
//
//	//int b = 5;
//	////权限缩小是可以的
//	//const int& rb = b;
//
//	int a = 4;
//	const int& ra = a * 3;//a * 3的结果存放在临时变量中，得用const引用
//
//	double d = 3.14;
//	const int& rd = d;//类型转换产生的中间值也存放在临时变量中，也得用const引用
//
//
//
//
//	return 0;
//}


//typedef int STDataType;
//struct Stack
//{
//	STDataType* arr;
//	int top;
//	int capacity;
//};
//
//typedef struct Stack ST;
//
//class Z
//{
//	void Print()
//	{
//		return;
//	}
//};
//
//class L
//{
//
//};


//关键字：class
//class cuboid//类名：长方体
//{
//public://访问限定符
//	//成员函数
//	int volume(int length, int breadth, int height)//计算长方体的体积
//	{
//		return length * breadth * height;
//	}
//
//	//void Init(cuboid* const this, int x, int y, int z)
//	void Init(int x, int y, int z)
//	{
//		_length = x;//  this->_length = x
//		_breadth = y;//  this->_breadth = y
//		_height = z;//  this->_height = z
//	}
//private:
//	//成员变量
//	int _length;//长
//	int _breadth;//宽
//	int _height;//高
//};
//int main()
//{
//	/*Z z;
//	L l;
//	cout << sizeof(z) << endl;
//	cout << sizeof(l) << endl;*/
//
//	cuboid box1;
//	cuboid box2;
//	box1.Init(1, 2, 3);
//	box2.Init(4, 5, 6);
//
//	return 0;
//}

//int cuboid::volume(int length, int breadth, int height)
//{
//	return length * breadth * height;
//}

typedef int STDataType;
//栈
class Stack
{
public:
	//默认构造
	Stack(int n = 4)
	{
		_a = (STDataType*)malloc(sizeof(STDataType) * n);
		if (_a == nullptr)
		{
			cout << "malloc fail" << endl;
			return;
		}
		_capacity = n;
		_top = 0;
	}

	//析构函数
	~Stack()
	{
		free(_a);
		_a = nullptr;
		_capacity = _top = 0;
	}

	//拷贝构造函数
	Stack(const Stack& st)
	{
		_a = (STDataType*)malloc(sizeof(STDataType) * st._capacity);
		if (_a == nullptr)
		{
			cout << "malloc fail" << endl;
			return;
		}

		memcpy(_a, st._a, sizeof(STDataType) * st._top);
		_top = st._top;
		_capacity = st._capacity;
	}

	/*Stack& operator=(const Stack& st)
	{
		return *this;
	}*/	

private:
	STDataType* _a;
	int _top;//有效数据个数
	int _capacity;//空间大小
};



int MoreThanHalfNum_Solution(vector<int>& nums) {
	// write code here
	/*int n = numbers.size();
	int HalfLen = n / 2;
	for (int i = 0; i < n; ++i)
	{
		int cnt = 0;
		for (int j = 0; j < n; j++)
		{
			if (numbers[i] == numbers[j])
			{
				++cnt;
			}
		}

		if (cnt > HalfLen)
		{
			return numbers[i];
		}
	}*/

	int x = nums[0];
	int cnt = 1;
	for (int i = 1; i < nums.size(); ++i)
	{
		if (cnt == 0)
		{
			x = nums[i];
			cnt = 1;
			continue;
		}
		x == nums[i] ? ++cnt : --cnt;
	}
	return x;
}

void test1()
{
	/*vector<int> nums(9,1);
	nums[1] = nums[3] = nums[4] = nums[5] = nums[8] = 2;
	nums[2] = 3;
	nums[6] = 5;
	nums[7] = 4;

	int ret = MoreThanHalfNum_Solution(nums);
	cout << ret;*/

	/*const char* str = "abcdefg";
	cout << strlen(str) << endl;*/
}

void test2()
{
	/*string a = "hello world";

	string b = a;

	if (a.c_str() == b.c_str())

	{

		cout << "true" << endl;

	}

	else cout << "false" << endl;

	string c = b;

	c = "";

	if (a.c_str() == b.c_str())

	{

		cout << "true" << endl;

	}

	else cout << "false" << endl;

	a = "";

	if (a.c_str() == b.c_str())

	{

		cout << "true" << endl;

	}

	else cout << "false" << endl;*/

	/*string str("Hello Bit.");

	str.reserve(111);

	str.resize(5);

	str.reserve(50);

	cout << str.size() << ":" << str.capacity() << endl;*/
}

void test3()
{
	string strText = "How are you?";

	string strSeparator = " ";

	string strResult;

	int size_pos = 0;

	int size_prev_pos = 0;

	while ((size_pos = strText.find_first_of(strSeparator, size_pos)) != string::npos)

	{

		strResult = strText.substr(size_prev_pos, size_pos - size_prev_pos);

		cout << strResult << " ";

		size_prev_pos = ++size_pos;

	}

	if (size_prev_pos != strText.size())

	{

		strResult = strText.substr(size_prev_pos, size_pos - size_prev_pos);

		cout << strResult << " ";

	}

	cout << endl;
}

void test4()
{
	string str = "A man, a plan, a canal: Panama";
	transform(str.begin(), str.end(), str.begin(),::tolower);
	cout << str << endl;
}

string reverseStr(string s, int k) {
	int n = s.size();
	//if (n == 1) return s;
	int l = 0;
	for (int l = 0; l < n; l += 2 * k)
	{
		int r = l + k - 1;
		r = min(r, n);//r == n是坑
		reverse(s.begin() + l, s.begin() + r);
	}
	return s;
}

void test5()
{
	string str = "abcdefg";
	reverseStr(str, 8);
	cout << str << endl;
}


void reverse(string& s, int left, int right)
{
	--right;
	while (left < right)
	{
		swap(s[left++], s[right--]);
		//++left;
		//--right;
	}
}


string reverseWords(string s)
{
	int prev_pos, pos;
	prev_pos = pos = 0;
	int n = s.size();
	for (int i = 0; i < n; ++i)
	{
		if (s[i] == ' ')
		{
			pos = i;
			reverse(s, prev_pos, pos);
			prev_pos = ++pos;
		}
	}
	reverse(s, prev_pos, n);
	return s;
}
void test6()
{
	string s = "Let's take LeetCode contest";
	reverseWords(s);
}

void test7()
{
	/*string str1 = "hello world!";
	string str2;
	str2 = str1.substr(6, -6);
	cout << str2 << endl;*/

	string s;
	cout << s.size() << endl;
	cout << s[0] << endl;
	printf("%c\n", s[0]);



}

string addStrings(string num1, string num2) {
	string ans;
	int next = 0;
	int end1 = num1.size() - 1, end2 = num2.size() - 1;
	while (end1 >= 0 || end2 >= 0)
	{
		int x = end1 >= 0 ? num1[end1--] - '0' : 0;
		int y = end2 >= 0 ? num2[end2--] - '0' : 0;
		int ret = x + y + next;
		next = ret / 10;
		ret %= 10;

		ans += (ret + '0');
	}

	if (next) ans += '1';
	reverse(ans.begin(), ans.end());
	return ans;
}
string multiply(string num1, string num2) {
	string ans = "0";
	string tmp;
	int end1 = num1.size() - 1, end2 = num2.size() - 1;
	int next = 0;
	int k = 0;
	while (end2 >= 0)
	{
		int val2 = num2[end2] - '0';
		while (end1 >= 0)
		{
			int val1 = num1[end1] - '0';
			next = val1 * val2 + next;
			tmp += (next % 10 + '0');
			next /= 10;
			--end1;
		}
		end1 = num1.size() - 1;
		reverse(tmp.begin(), tmp.end());
		tmp.insert(tmp.end(), k, '0');
		++k;
		ans = addStrings(ans, tmp);
		tmp = "";
		--end2;
	}
	return ans;
}

void test8()
{
	string s1 = "123";
	string s2 = "456";
	string ans = multiply(s1, s2);
	cout << ans << endl;
}

//vector<vector<int>> levelOrder(TreeNode* root) {
//	vector<vector<int>> ans;
//	queue<TreeNode*> q;
//	int levelSize = 0;
//	if (root)
//	{
//		q.push(root);
//		levelSize = 1;
//	}
//
//	while (!q.empty())
//	{
//		vector<int> v;
//		while (levelSize--)
//		{
//
//			TreeNode* front = q.front();
//			q.pop();
//
//			v.push_back(front->val);
//			if (front->left) q.push(front->left);
//			if (front->right) q.push(front->right);
//		}
//		ans.push_back(v);
//		levelSize = q.size();
//	}
//	return ans;
//}

int main()
{
	test8();
	return 0;

}







